/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include <节点/节点.h>
#include <core/空间划分/球形八叉树.h>



void f_node_所有网格类节点JIT初始化();



class C_计算网格法线节点 : public C_节点基类 {
	S_点距八叉树* m_Tree;
public:
	C_计算网格法线节点(S_设备环境& ctx);
	~C_计算网格法线节点();

	S_Props		m_法线类型;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建计算网格法线节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入计算网格法线节点(S_设备环境& ctx, FILE* f);
void		f_node_保存计算网格法线节点(C_节点基类* n, FILE* f);





class C_网格体素节点 : public C_节点基类 {
	//S_设备环境	m_GPU环境;
	//S_物体* m_当前拷贝物体根物体;
public:
	C_网格体素节点(S_设备环境& ctx);
	~C_网格体素节点();

	bool	f_update();
};

C_节点基类* f_node_创建网格体素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入网格体素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存网格体素节点(C_节点基类* n, FILE* f);





class C_取网格属性节点 : public C_节点基类 {
	//S_设备环境	m_GPU环境;
	//S_物体* m_当前拷贝物体根物体;
public:
	C_取网格属性节点(S_设备环境& ctx);
	~C_取网格属性节点();

	S_Props		m_网格属性;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取网格属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取网格属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取网格属性节点(C_节点基类* n, FILE* f);





class C_截取网格节点 : public C_节点基类 {
	S_点距八叉树* m_Tree;
	S_Mesh* m_Mesh;
public:
	C_截取网格节点(S_设备环境& ctx);
	~C_截取网格节点();

	S_Props		m_截取方式;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建截取网格节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入截取网格节点(S_设备环境& ctx, FILE* f);
void		f_node_保存截取网格节点(C_节点基类* n, FILE* f);




class C_填充网格顶点节点 : public C_节点基类 {
public:
	C_填充网格顶点节点(S_设备环境& ctx);
	~C_填充网格顶点节点();

	S_Props		m_网格属性;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建填充网格顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入填充网格顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存填充网格顶点节点(C_节点基类* n, FILE* f);



class C_填充网格纹理坐标节点 : public C_节点基类 {
public:
	C_填充网格纹理坐标节点(S_设备环境& ctx);
	~C_填充网格纹理坐标节点();

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建填充网格纹理坐标节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入填充网格纹理坐标节点(S_设备环境& ctx, FILE* f);
void		f_node_保存填充网格纹理坐标节点(C_节点基类* n, FILE* f);



class C_面朝向节点 : public C_节点基类 {
	std::vector<uint32> m_顶点索引;
public:
	C_面朝向节点(S_设备环境& ctx);
	~C_面朝向节点();

	bool	f_update();
};

C_节点基类* f_node_创建面朝向节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入面朝向节点(S_设备环境& ctx, FILE* f);
void		f_node_保存面朝向节点(C_节点基类* n, FILE* f);



class C_设置材质ID节点 : public C_节点基类 {
	S_板载缓存* m_以前的材质;
public:
	C_设置材质ID节点(S_设备环境& ctx);
	~C_设置材质ID节点();

	S_Props		m_网格属性;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置材质ID节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置材质ID节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置材质ID节点(C_节点基类* n, FILE* f);



class C_设置网格属性节点 : public C_节点基类 {
	S_板载缓存* m_以前的材质;
public:
	C_设置网格属性节点(S_设备环境& ctx);
	~C_设置网格属性节点();

	S_Props		m_网格属性;
	S_Props		m_执行代码;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置网格属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置网格属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置网格属性节点(C_节点基类* n, FILE* f);




class C_多边形删除顶点节点 : public C_节点基类 {
	S_物体* m_Ob;
public:
	C_多边形删除顶点节点(S_设备环境& ctx);
	~C_多边形删除顶点节点();

	bool	f_update();

	S_物体* f_get虚拟体();
	void	f_入回收();
	void	f_回收();
};

C_节点基类* f_node_创建多边形删除顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形删除顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形删除顶点节点(C_节点基类* n, FILE* f);




class C_构建多边形面节点 : public C_节点基类 {
	S_物体* m_Ob;
public:
	C_构建多边形面节点(S_设备环境& ctx);
	~C_构建多边形面节点();

	S_Props	m_面朝向;

	bool	f_update();
	std::string	DEF_节点编译函数;
	S_物体* f_get虚拟体();
	void	f_入回收();
	void	f_回收();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建构建多边形面节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入构建多边形面节点(S_设备环境& ctx, FILE* f);
void		f_node_保存构建多边形面节点(C_节点基类* n, FILE* f);



class C_从索引构建面纹理坐标节点 : public C_节点基类 {

public:
	C_从索引构建面纹理坐标节点(S_设备环境& ctx);
	~C_从索引构建面纹理坐标节点();

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建构建面纹理坐标节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入构建面纹理坐标节点(S_设备环境& ctx, FILE* f);
void		f_node_保存构建面纹理坐标节点(C_节点基类* n, FILE* f);



class C_边倒角 : public C_节点基类 {

public:
	C_边倒角(S_设备环境& ctx);
	~C_边倒角();

	S_Props	m_细分类型;
	bool	f_update();
	//void	f_读取(FILE* f);
	//void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形倒角节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形倒角节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形倒角节点(C_节点基类* n, FILE* f);




class C_多边形桥接 : public C_节点基类 {
	S_物体* m_Ob;
public:
	C_多边形桥接(S_设备环境& ctx);
	~C_多边形桥接();

	//S_Props	m_细分类型;
	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	//void	f_读取(FILE* f);
	//void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形桥接节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形桥接节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形桥接节点(C_节点基类* n, FILE* f);


class C_点桥接 : public C_节点基类 {
	S_物体* m_Ob;
public:
	C_点桥接(S_设备环境& ctx);
	~C_点桥接();
	//S_Props	m_细分类型;
	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建点桥接节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入点桥接节点(S_设备环境& ctx, FILE* f);
void		f_node_保存点桥接节点(C_节点基类* n, FILE* f);



class C_多边形边采样 : public C_节点基类 {
	//S_物体* m_Ob;
public:
	C_多边形边采样(S_设备环境& ctx);
	~C_多边形边采样();

	S_Props	m_多点采样;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形边采样节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形边采样节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形边采样节点(C_节点基类* n, FILE* f);




class C_多边形边实体化 : public C_节点基类 {
	
public:
	C_多边形边实体化(S_设备环境& ctx);
	~C_多边形边实体化();

	S_Props	m_半径模式;
	S_Props	m_倒角类型;
	S_Props		m_曲线;

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形边实体化节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形边实体化节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形边实体化节点(C_节点基类* n, FILE* f);




class C_多边形边网格化 : public C_节点基类 {
	S_物体* m_Ob;
public:
	C_多边形边网格化(S_设备环境& ctx);
	~C_多边形边网格化();

	//S_Props	m_细分类型;
	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	
};

C_节点基类* f_node_创建多边形边网格化节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形边网格化节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形边网格化节点(C_节点基类* n, FILE* f);




class C_网格选择节点 : public C_节点基类 {
	//S_物体* m_Ob;
public:
	C_网格选择节点(S_设备环境& ctx);
	~C_网格选择节点();

	S_Props	m_选择类型;

	bool	f_update();
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建网格选择节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入网格选择节点(S_设备环境& ctx, FILE* f);
void		f_node_保存网格选择节点(C_节点基类* n, FILE* f);




class C_设置多边形面属性节点 : public C_节点基类 {

public:
	C_设置多边形面属性节点(S_设备环境& ctx);
	~C_设置多边形面属性节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置多边形属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置多边形属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置多边形属性节点(C_节点基类* n, FILE* f);




class C_设置多边形面UV节点 : public C_节点基类 {

public:
	C_设置多边形面UV节点(S_设备环境& ctx);
	~C_设置多边形面UV节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置多边形面UV节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置多边形面UV节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置多边形面UV节点(C_节点基类* n, FILE* f);




class C_多边形复制节点 : public C_节点基类 {

public:
	C_多边形复制节点(S_设备环境& ctx);
	~C_多边形复制节点();

	S_Props	m_合并类型;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形复制节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形复制节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形复制节点(C_节点基类* n, FILE* f);



class C_多边形拷贝节点 : public C_节点基类 {
public:
	C_多边形拷贝节点(S_设备环境& ctx);
	~C_多边形拷贝节点();
	S_Props	m_属性;
	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建拷贝多边形节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入拷贝多边形节点(S_设备环境& ctx, FILE* f);
void		f_node_保存拷贝多边形节点(C_节点基类* n, FILE* f);



class C_多边形变换节点 : public C_节点基类 {

public:
	C_多边形变换节点(S_设备环境& ctx);
	~C_多边形变换节点();
	S_Props	m_属性;
	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形变换节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形变换节点(C_节点基类* n, FILE* f);



class C_多边形四元数变换节点 : public C_节点基类 {
public:
	C_多边形四元数变换节点(S_设备环境& ctx);
	~C_多边形四元数变换节点();

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形四元数变换节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形四元数变换节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形四元数变换节点(C_节点基类* n, FILE* f);





class C_取多边形元素节点 : public C_节点基类 {
public:
	C_取多边形元素节点(S_设备环境& ctx);
	~C_取多边形元素节点();

	bool	f_update();
	std::string	DEF_节点编译函数;
	//void	f_读取(FILE* f);
	//void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形元素节点(C_节点基类* n, FILE* f);



class C_取多边形面节点 : public C_节点基类 {
public:
	C_取多边形面节点(S_设备环境& ctx);
	~C_取多边形面节点();

	bool	f_update();
	std::string	DEF_节点编译函数;
	//void	f_读取(FILE* f);
	//void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形面节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形面节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形面节点(C_节点基类* n, FILE* f);



class C_取多边形面属性节点 : public C_节点基类 {

public:
	C_取多边形面属性节点(S_设备环境& ctx);
	~C_取多边形面属性节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形属性节点(C_节点基类* n, FILE* f);




class C_取多边形面顶点节点 : public C_节点基类 {
public:
	C_取多边形面顶点节点(S_设备环境& ctx);
	~C_取多边形面顶点节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形面顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形面顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形面顶点节点(C_节点基类* n, FILE* f);



class C_设置多边形面顶点节点 : public C_节点基类 {
public:
	C_设置多边形面顶点节点(S_设备环境& ctx);
	~C_设置多边形面顶点节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建设置多边形面顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置多边形面顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置多边形面顶点节点(C_节点基类* n, FILE* f);




class C_取多边形面UV节点 : public C_节点基类 {
public:
	C_取多边形面UV节点(S_设备环境& ctx);
	~C_取多边形面UV节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形面UV节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形面UV节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形面UV节点(C_节点基类* n, FILE* f);



class C_取多边形_边 : public C_节点基类 {
public:
	C_取多边形_边(S_设备环境& ctx);
	~C_取多边形_边();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形_边节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形_边节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形_边节点(C_节点基类* n, FILE* f);



class C_取多边形_元素 : public C_节点基类 {
public:
	C_取多边形_元素(S_设备环境& ctx);
	~C_取多边形_元素();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取多边形_元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取多边形_元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取多边形_元素节点(C_节点基类* n, FILE* f);



class C_多边形转网格节点 : public C_节点基类 {
public:
	C_多边形转网格节点(S_设备环境& ctx);
	~C_多边形转网格节点();

	S_Props	m_拷贝;
	S_Props	m_合并顶点;
	S_Props	m_平滑法线;

	bool	f_update();
	//std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建多边形转网格节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入多边形转网格节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形转网格节点(C_节点基类* n, FILE* f);



class C_取网格元素节点 : public C_节点基类 {
public:
	C_取网格元素节点(S_设备环境& ctx);
	~C_取网格元素节点();

	S_Props	m_元素类型;

	bool	f_update();
	//std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建取网格元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取网格元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取网格元素节点(C_节点基类* n, FILE* f);



class C_取网格元素顶点节点 : public C_节点基类 {
public:
	C_取网格元素顶点节点(S_设备环境& ctx);
	~C_取网格元素顶点节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建取网格元素顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入取网格元素顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取网格元素顶点节点(C_节点基类* n, FILE* f);



class C_设置网格元素顶点节点 : public C_节点基类 {
public:
	C_设置网格元素顶点节点(S_设备环境& ctx);
	~C_设置网格元素顶点节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	//void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建设置网格元素顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入设置网格元素顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存设置网格元素顶点节点(C_节点基类* n, FILE* f);



class C_网格顶点节点 : public C_节点基类 {
public:
	C_网格顶点节点(S_设备环境& ctx);
	~C_网格顶点节点();

	S_Props	m_属性;

	bool	f_update();
	std::string	DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	//void    f_getStr(std::vector<std::vector<std::wstring>>& 文本);
};

C_节点基类* f_node_创建网格顶点节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_载入网格顶点节点(S_设备环境& ctx, FILE* f);
void		f_node_保存网格顶点节点(C_节点基类* n, FILE* f);







